﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace PickGold.Collections
{
	class SortedCollection<TKey, TValue> : IDictionary<TKey, TValue>, IList<TValue>
	{
		private IList<TValue> _List;
		private IDictionary<TKey, TValue> _Dictionary;
		// 摘要:
		//     初始化 System.Collections.Generic.SortedDictionary<TKey,TValue> 类的一个新实例，该实例为空并对键类型使用默认
		//     System.Collections.Generic.IComparer<T> 实现。
		public SortedCollection()
		{
			this._List = new List<TValue>();
			this._Dictionary = new SortedDictionary<TKey, TValue>();
		}
		//
		// 摘要:
		//     初始化 System.Collections.Generic.SortedDictionary<TKey,TValue> 类的一个新实例，该实例为空并使用指定的
		//     System.Collections.Generic.IComparer<T> 实现来比较键。
		//
		// 参数:
		//   comparer:
		//     在比较键时要使用的 System.Collections.Generic.IComparer<T> 实现；或者为 null，表示为键类型使用默认的
		//     System.Collections.Generic.Comparer<T>。
		public SortedCollection(IComparer<TKey> comparer)
		{
			this._List = new List<TValue>();
			this._Dictionary = new SortedDictionary<TKey, TValue>(comparer);
		}
		//
		// 摘要:
		//     初始化 System.Collections.Generic.SortedDictionary<TKey,TValue> 类的新实例，该实例包含从指定的
		//     System.Collections.Generic.IDictionary<TKey,TValue> 中复制的元素，并使用键类型的默认 System.Collections.Generic.IComparer<T>
		//     实现。
		//
		// 参数:
		//   dictionary:
		//     System.Collections.Generic.IDictionary<TKey,TValue>，它的元素被复制到新的 System.Collections.Generic.SortedDictionary<TKey,TValue>
		//     中。
		//
		// 异常:
		//   System.ArgumentNullException:
		//     dictionary 为 null。
		//
		//   System.ArgumentException:
		//     dictionary 包含一个或多个重复键。
		public SortedCollection(IDictionary<TKey, TValue> dictionary)
		{
			this._List = new List<TValue>();
			foreach (var value in dictionary.Values)
				this._List.Add(value);
			this._Dictionary = new SortedDictionary<TKey, TValue>(dictionary);
		}
		//
		// 摘要:
		//     初始化 System.Collections.Generic.SortedDictionary<TKey,TValue> 类的新实例，该实例包含从指定的
		//     System.Collections.Generic.IDictionary<TKey,TValue> 中复制的元素，并使用指定的 System.Collections.Generic.IComparer<T>
		//     实现来比较键。
		//
		// 参数:
		//   dictionary:
		//     System.Collections.Generic.IDictionary<TKey,TValue>，它的元素被复制到新的 System.Collections.Generic.SortedDictionary<TKey,TValue>
		//     中。
		//
		//   comparer:
		//     在比较键时要使用的 System.Collections.Generic.IComparer<T> 实现；或者为 null，表示为键类型使用默认的
		//     System.Collections.Generic.Comparer<T>。
		//
		// 异常:
		//   System.ArgumentNullException:
		//     dictionary 为 null。
		//
		//   System.ArgumentException:
		//     dictionary 包含一个或多个重复键。
		public SortedCollection(IDictionary<TKey, TValue> dictionary, IComparer<TKey> comparer)
		{
			this._List = new List<TValue>();
			foreach (var value in dictionary.Values)
				this._List.Add(value);
			this._Dictionary = new SortedDictionary<TKey, TValue>(dictionary, comparer);
		}


		public void Add(TKey key, TValue value)
		{
			this._List.Add(value);
			this._Dictionary.Add(key, value);
		}

		public bool ContainsKey(TKey key)
		{
			return this._Dictionary.ContainsKey(key);
		}

		public ICollection<TKey> Keys
		{
			get
			{
				return this._Dictionary.Keys;
			}
		}

		public bool Remove(TKey key)
		{
			throw new NotImplementedException();
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			return this._Dictionary.TryGetValue(key, out value);
		}

		public ICollection<TValue> Values
		{
			get
			{
				return this._Dictionary.Values;
			}
		}

		public TValue this[TKey key]
		{
			get
			{
				return this._Dictionary[key];
			}
			set
			{
				this._Dictionary[key] = value;
			}
		}

		public void Add(KeyValuePair<TKey, TValue> item)
		{
			this._Dictionary.Add(item);
		}

		public void Clear()
		{
			this._List.Clear();
			this._Dictionary.Clear();
		}

		public bool Contains(KeyValuePair<TKey, TValue> item)
		{
			return this._Dictionary.Contains(item);
		}

		public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			this._Dictionary.CopyTo(array, arrayIndex);
		}

		public int Count
		{
			get {
				return this._Dictionary.Count;
			}
		}

		public bool IsReadOnly
		{
			get {
				return this._List.IsReadOnly;
			}
		}

		public bool Remove(KeyValuePair<TKey, TValue> item)
		{
			return this._Dictionary.Remove(item);
		}

		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			return this._Dictionary.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return this._Dictionary.GetEnumerator();
		}

		public int IndexOf(TValue item)
		{
			throw new NotImplementedException();
		}

		public void Insert(int index, TValue item)
		{
			this._List.Insert(index, item);
		}

		public void RemoveAt(int index)
		{
			this._List.RemoveAt(index);
		}

		public TValue this[int index]
		{
			get
			{
				return this._List[index];
			}
			set
			{
				this._List[index] = value;
			}
		}

		public void Add(TValue item)
		{
			this._List.Add(item);
		}

		public bool Contains(TValue item)
		{
			return this._List.Contains(item);
		}

		public void CopyTo(TValue[] array, int arrayIndex)
		{
			this._List.CopyTo(array, arrayIndex);
		}

		public bool Remove(TValue item)
		{
			return this._List.Remove(item);
		}

		IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator()
		{
			return this._List.GetEnumerator();
		}
	}
}
